package com.panda.sports.manager.query;

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.panda.sports.manager.constant.Constant;
import com.panda.sports.manager.entity.StandardSportTournament;
import com.panda.sports.manager.entity.ThirdSportTournament;
import com.panda.sports.manager.enums.TourLevelEnum;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import java.util.ArrayList;
import java.util.List;

/**
 * 前端传入的查询条件对象
 *
 * @author dorich
 * @ 前端传入的查询条件对象
 * @date 2019-08-01 19:21
 * @modificationHistory Who    When    What
 * --------  ---------  --------------------------
 */

@Data
@Slf4j
@ApiModel(description = "联赛查询条件")
public class TournamentQuery {

    public static List<String> DATA_SOURCE_LIST = new ArrayList<>();

    static {
        DATA_SOURCE_LIST.add(Constant.DATA_SOURCE_SR);
        DATA_SOURCE_LIST.add(Constant.DATA_SOURCE_BC);
    }

    /**
     * 是否仅查询标准联赛的默认值
     */
    public static Integer DEFAULT_VALUE_ONLY_QUERY = 1;
    /**
     * 联赛状态：有联赛ID
     **/
    public static Integer TOUR_ID_STATUS_YES = 1;

    /**
     * 联赛状态：无联赛ID
     **/
    public static Integer TOUR_ID_STATUS_NO = 0;
    /**
     * 数据库中int  和  long 的默认值
     **/
    public static Integer DEFAULT_VALUE_INT = 0;

    /**
     * 每页数据个数
     **/
    @ApiModelProperty(name = "每页数据量，默认50")
    private Integer size = 50;


    @ApiModelProperty(name = "是否仅查询标准联赛", notes = "1:仅查询标准联赛")
    private Integer onlyStandard;

    /**
     * 从第几页开始
     **/
    @ApiModelProperty(name = "从第几页开始，默认1")
    private Integer page = 1;

    @ApiModelProperty(name = "标准联赛的id", notes = "标准联赛的id")
    private Long id;

    /**
     * 联赛级别
     **/
    @ApiModelProperty(name = "联赛级别", allowableValues = "range[0,5]", notes = "0-5分别代表：未评级；1级；2级；以此类推；不传代表全部")
    private Integer tournamentLevel;

    /**
     * 联赛所属体育地区id
     **/
    @ApiModelProperty(name = "联赛所属地区id", allowableValues = "range[1, infinity]")
    private Long sportRegionId;

    /**
     * 数据来源编码。
     **/
    @ApiModelProperty(name = "联赛数据来源编码列表", notes = "联赛数据来源编码列表. SR BC MA:已匹配；UMA:未匹配；其余值: 全部")
    private List<String> dataSourceCode;

    /**
     * 后台管理使用的联赛id
     **/
    @ApiModelProperty(name = "管理使用联赛ID", allowableValues = "range[1, infinity]")
    private Long tournamentManagerId;

    @ApiModelProperty(name = "联赛ID状态", allowableValues = "range[0,1]", notes = "联赛ID状态.0:无联赛ID; 1:有联赛ID; 其余值:全部")
    private Integer tournamentManagerIdStatus;
    /**
     * 联赛名称
     **/
    @ApiModelProperty(name = "查询的联赛名")
    private String tournamentName;


    /**
     * 根据查询条件，生成标准联赛的query
     *
     * @param query 查询条件
     * @return com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper
     * @description 生成查询条件
     * @author dorich
     * @date 2019/8/4
     **/
    private static UpdateWrapper getStandardWrapper(TournamentQuery query) {
        UpdateWrapper<StandardSportTournament> queryWrapper = new UpdateWrapper<>();
        queryWrapper.lambda().eq(StandardSportTournament::getSportId, Constant.SPORT_TYPE_FOOTBALL);
        queryWrapper.lambda().ne(StandardSportTournament::getThirdTournamentId, DEFAULT_VALUE_INT);

        // 前端希望仅使用1个id 查询 指定标准联赛的数据
        if(null != query.getId() && query.getId() > 0) {
            queryWrapper.lambda().eq(StandardSportTournament::getId, query.getId());
        }
        // 联赛级别->如果不是全部
        if (null != query.getTournamentLevel() && query.getTournamentLevel() >= 0 && query.getTournamentLevel() <= Constant.MAX_LEVEL) {
            queryWrapper.lambda().eq(StandardSportTournament::getTournamentLevel, query.getTournamentLevel());
        }

        // 联赛数据源
        if (null != query.getDataSourceCode()) {
            if (query.getDataSourceCode().contains(Constant.DATA_SOURCE_BC) && query.getDataSourceCode().contains(Constant.DATA_SOURCE_SR)) {

            } else if (query.getDataSourceCode().contains(Constant.DATA_SOURCE_BC)) {
                queryWrapper.lambda().eq(StandardSportTournament::getDataSourceCode, Constant.DATA_SOURCE_BC);
            } else if (query.getDataSourceCode().contains(Constant.DATA_SOURCE_SR)) {
                queryWrapper.lambda().eq(StandardSportTournament::getDataSourceCode, Constant.DATA_SOURCE_SR);
            }
        }

        // 联赛ID状态
        if (null != query.getTournamentManagerIdStatus()) {
            //  无联赛ID
            if (query.getTournamentManagerIdStatus().equals(TournamentQuery.TOUR_ID_STATUS_NO)) {
                // 联赛管理的ID 默认为 0
                queryWrapper.lambda().eq(StandardSportTournament::getTournamentManagerId, TournamentQuery.TOUR_ID_STATUS_NO);
            }
            // 有联赛ID
            if (query.getTournamentManagerIdStatus().equals(TournamentQuery.TOUR_ID_STATUS_YES)) {
                // 联赛管理的ID 默认为 1
                queryWrapper.lambda().ne(StandardSportTournament::getTournamentManagerId, TournamentQuery.TOUR_ID_STATUS_NO);

            }
        }

        // 联赛ID 如果查询条件包含 指定的联赛ID
        if (null != query.getTournamentManagerId()) {
            queryWrapper.lambda().eq(StandardSportTournament::getTournamentManagerId, query.getTournamentManagerId());
        }

        // 联赛地区
        if (null != query.getSportRegionId()) {
            queryWrapper.lambda().eq(StandardSportTournament::getStandardSportRegionId, query.getSportRegionId());
        }

        // 联赛名称
        if (null != query.getTournamentName()) {
            // 简称包含关键字
            queryWrapper.lambda().like(StandardSportTournament::getName, query.getTournamentName());

        }
        queryWrapper.lambda().orderByDesc(StandardSportTournament::getId);
        return queryWrapper;
    }


    /**
     * 根据查询条件生成 第三方联赛的查询wrapper
     *
     * @param query 查询条件
     * @return com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper
     * @description 生成查询条件
     * @author dorich
     * @date 2019/8/4
     **/
    private static UpdateWrapper getThirdWrapper(TournamentQuery query) {

        UpdateWrapper<ThirdSportTournament> queryWrapper = new UpdateWrapper<>();
        // 此查询条件中仅查询 未关联数据，关联的数据根据表联赛条件进行查询。
        queryWrapper.lambda().eq(ThirdSportTournament::getReferenceId, TournamentQuery.DEFAULT_VALUE_INT);
        queryWrapper.lambda().in(ThirdSportTournament::getDataSourceCode, TournamentQuery.DATA_SOURCE_LIST);
        queryWrapper.lambda().eq(ThirdSportTournament::getSportId,  Constant.SPORT_TYPE_FOOTBALL);
        //如果仅查询标准赛事，则不查询 第三方赛事
        if (null != query.getOnlyStandard() && query.getOnlyStandard().intValue() == DEFAULT_VALUE_ONLY_QUERY) {
            return null;
        }

        // 前端希望仅使用1个id 查询 指定标准联赛的数据
        if(null != query.getId() && query.getId() > 0) {
            return null;
        }

        // 联赛级别 -> 如果是未评级
        if (null != query.getTournamentLevel()) {
            // 指定了联赛级别
            boolean isCertainLevel = query.getTournamentLevel() > TourLevelEnum.UNDEFINE.getValue()
                    && (query.getTournamentLevel() <= TourLevelEnum.FIVE.getValue());
            if (isCertainLevel) {
                // 如果指定联赛级别，则 不再查询未关联数据
                return null;
            }
            // 指定了查询未评级数据
            else if (query.getTournamentLevel().intValue() == TourLevelEnum.UNDEFINE.getValue()) {
                // 第三方联赛数据中，未关联联赛的 关联字段 默认为0
                queryWrapper.lambda().eq(ThirdSportTournament::getReferenceId, TournamentQuery.DEFAULT_VALUE_INT);
            }
        }

        // 联赛 数据源。
        if (null != query.getDataSourceCode()) {
            if (query.getDataSourceCode().contains(Constant.DATA_SOURCE_MA)) {
                // 已匹配的数据由 标准联赛查询后根据其他条件查询
                return null;
            }
            if (query.getDataSourceCode().contains(Constant.DATA_SOURCE_UM)) {
                queryWrapper.lambda().eq(ThirdSportTournament::getReferenceId, TournamentQuery.DEFAULT_VALUE_INT);
            }
            if (query.getDataSourceCode().contains(Constant.DATA_SOURCE_BC) && query.getDataSourceCode().contains(Constant.DATA_SOURCE_SR)) {
                log.info("");
            } else if (query.getDataSourceCode().contains(Constant.DATA_SOURCE_BC)) {
                queryWrapper.lambda().eq(ThirdSportTournament::getDataSourceCode, Constant.DATA_SOURCE_BC);
            } else if (query.getDataSourceCode().contains(Constant.DATA_SOURCE_SR)) {
                queryWrapper.lambda().eq(ThirdSportTournament::getDataSourceCode, Constant.DATA_SOURCE_SR);
            }
        }

        // 联赛ID状态 作为条件
        if (null != query.getTournamentManagerIdStatus()) {
            //  无联赛ID
            if (query.getTournamentManagerIdStatus().equals(TournamentQuery.TOUR_ID_STATUS_NO)) {
                // 联赛管理的ID  没有被关联，则关联联赛id  默认为 0
                queryWrapper.lambda().eq(ThirdSportTournament::getReferenceId, TournamentQuery.DEFAULT_VALUE_INT);
            }
            // 有联赛ID
            if (query.getTournamentManagerIdStatus().equals(TournamentQuery.TOUR_ID_STATUS_YES)) {
                // 有联赛管理的ID 默认为 1。则不直接查询第三方联赛数据。 需要的第三方数据由 标准联赛查询结果进行查询。
                return null;
            }
        }

        // 联赛ID 如果查询条件包含 指定的联赛ID
        if (null != query.getTournamentManagerId() && query.getTournamentManagerId().intValue() > 0) {
            return null;
        }

        // 联赛地区
        if (null != query.getSportRegionId() && query.getSportRegionId().intValue() >= 0) {
            // 指定第三方联赛的联赛地区 id
            queryWrapper.lambda().eq(ThirdSportTournament::getSportRegionId, query.getSportRegionId().toString());
        }

        // 联赛名称
        if (null != query.getTournamentName()) {
            // 简称包含关键字
            queryWrapper.lambda().like(ThirdSportTournament::getName, query.getTournamentName());
        }
        return queryWrapper;
    }

    public static UpdateWrapper getWrapper(Class<?> clas, TournamentQuery query) {
        if (clas.equals(StandardSportTournament.class)) {
            log.info(clas.getName());
            return getStandardWrapper(query);
        }
        if (clas.equals(ThirdSportTournament.class)) {
            log.info(clas.getName());
            return getThirdWrapper(query);
        }
        return null;
    }
}